﻿###Function###
StringRegExp

###Description###
Prüft, ob ein String dem Suchmuster eines regulären Ausdrucks entspricht.

###Syntax###
StringRegExp ( "test", "pattern" [, flag = 0 [, offset = 1]] )


###Parameters###
@@ParamTable@@
test
	Die zu prüfende Eingabe
pattern
	Das Suchmuster des regulären Ausdrucks.
flag
	[optional] Eine Zahl, die die Verhaltensweise der Funktion bestimmt. Siehe weiter unten für Details. Der Standard ist 0.
offset
	[optional] Die Position des Strings, wo die Funktion beginnen soll (startet bei 1). Der Standard ist 1.
@@End@@
<br>
@@ParamTable@@
<b>Flag</b>
	<b>Werte</b>
0
	Gibt 1 (Übereinstimmung gefunden) oder 0 (Übereinstimmung nicht gefunden) zurück.
1
	Gibt ein Array mit der ersten Übereinstimmung zurück.
2
	Gibt ein Array mit den Übereinstimmungen zurück inkl. der vollständigen Übereinstimmung (Perl / PHP Stil).
3
	Gibt ein Array mit den globalen Übereinstimmungen zurück.
4
	Gibt ein Array mit den globalen Übereinstimmungen zurück inkl. der vollständigen Übereinstimmung (Perl / PHP Stil).
@@End@@

###ReturnValue###
<i>Flag = 0 :</i>

@@ReturnTable@@
@error	Bedeutung
	2 	Falsches Muster. @Extended = Offset des Fehlers im Muster.
@@End@@

<i>Flag = 1 oder 2 :</i>

@@ReturnTable@@
@error	Bedeutung
	0	Array ist gültig. Siehe @extended für die weiteren Offsets überprüfen.
	1	Array ist ungültig. Keine Übereinstimmungen.
	2	Falsches Suchmuster, Array ist ungültig. @Extended = Offset des Fehlers im Muster.
@@End@@

<i>Flag = 3 oder 4 :</i>

@@ReturnTable@@
@error	Bedeutung
	0	Array ist gültig.
	1	Array ist ungültig. Keine Übereinstimmungen.
	2	Falsches Suchmuster, Array ist ungültig. @Extended = Offset des Fehlers im Muster.
@@End@@


###Remarks###
Der Flag-Parameter kann einen von den fünf Werten annehmen (Null bis Vier).
Flag 0 gibt bei einer Übereinstimmung 1 (true) zurück und 0 (false) bei keiner Übereinstimmung.
Flag 1 und 2 suchen die erste Übereinstimmung und geben die übereinstimmenden gefundenen Gruppen in einem Array zurück.
	Sollte ein Suchmuster keine Suchgruppen enthalten so wird nur der erste Fund in einem Array zurückgegeben.
Flag 3 und 4 geben ein Array zurück mit allen gefundenen Suchgruppeninstanzen.
Flags 2 und 4 beinhalten im Rückgabearray im ersten Element den komplett übereinstimmenden Text und nicht nur die gefundenen Gruppen wie bei Flag 1 und 3.

Reguläre Ausdrücke sind Strings, in denen einfache Textzeichen angeben, welcher Text in dem Zielstring existieren muss.
Einige Zeichen haben eine besondere Bedeutung, um anzugeben, welche Variabilität in dem Zielstring erlaubt ist. Für reguläre Ausdrücke in AutoIt ist normalerweise die Groß-/Kleinschreibung relevant.
Dabei kann man die gefundenen Strings entweder mit <a href="StringRegExp.htm">StringRegExp()</a> extrahieren oder mit <a href="StringRegExpReplace.htm">StringRegExpReplace()</a> ersetzen.

Dabei sucht die Engine des Parses für die regulären Ausdrücke nach dem programmartigen Suchmuster und geht zur letzten erfolgreichen Suchstelle zurück, wenn ein Fund nicht mehr dem Format entspricht.
So geht es den gesamten Eingabestring durch und returnt je nach Flag die entsprechenden Ergebnisse.

Das sogenannte Backtrackking ist eines der fundamentalsten Features eines Parsers für reguläre Ausdrücke und bereits jeder Programmierneuling sollte es bereits verstehen und täglich anwenden.
Es hinterlässt eine spezielle Haltemarke an jeder Weggabelung des Codes und man geht zu jener Haltemarke zurück wenn der aktuelle Codepfad sich als Sackgasse herausstellt.
Man backtrackt so weit zurück bis man entweder den richtigen Punkt findet (hier wäre es eine Übereinstimmung) oder bis man jeden Pfad erkundet hat ohne sein Ziel zu erreichen (keine Übereinstimmung gefunden).
Das suchen eines Dateinamens mit optionalen Wildcards (*) innerhalb einer Ordnerstruktur ist genau dasselbe.

AutoIt benutzt die PCRE Engine. PCRE bedeutet "Perl-Compatible Regular Expressions" und ist die umfassenste open-source Engine die verfügbar ist.
Diese Implementation bringt die sogenannte Unicode Category Properties (UCP) Unterstützung mit sich, welche es erlaubt die meisten von menschenhand entwickelten Sprachen sehr säuberlich zu parsen.
Um jedoch Vorgängerkompabilität zu alten AutoIt-Versionen zu wahren und die Geschwindigkeit der Übereinstimmungssuche so hoch wie möglich zu halten, <b>ist der UCP Support standardmäßig nicht aktiviert</b>.

Diese Seite ist nur eine Zusammenfassung der gängigsten Suchmuster. Für einen kompletten Einblick der PCRE-Suchmuster, welche in AutoIt implementiert sind, sollte man einen Blick <b><a href="http://www.autoitscript.com/autoit3/pcrepattern.html" target="_blank">auf diese Seite werfen</a></b>.
Sollte man nicht bereits wissen wie reguläre Ausdrücke funktionieren, so sollte man sich vorher die verlinkte Dokumentation gründlich durchlesen um überhaupt im Ansatz zu wissen wie man an reguläre Ausdrücke angeht.

Reguläre Ausdrücke werden aus einem oder mehreren der folgenden einfachen Sonderzeichen gebildet. Ist ein Zeichen nicht in der folgenden Tabelle enthalten, dann steht es nur für sich selbst.

Wiederholungszeichen oder auch Quantifizierer genannt (*, +, ?, {...} ) versuchen die größtmögliche Entsprechung zu finden, außer wenn ihnen direkt ein Fragezeichen folgt; dann wird die kleinstmögliche Entsprechung der nachfolgenden Zeichen genommen.

Verschachtelte Gruppen sind erlaubt, aber es ist zu beachten, dass alle Gruppen dem zurückgegebenen Array zugewiesen werden, wobei die äußeren nach den inneren Gruppen berücksichtigt werden. Verwendet man statt der normalen Gruppierung () eine nicht-fangende Gruppierung (?: ... ) oder (?> ... ) wird die Gruppe dem zurückgegebenen Array nicht hinzugefügt.

Alles was in einer runden Klammer "()" steht wird als Gruppe bzw. Subpattern bezeichnet. Der Inhalt muß komplett in dem zu prüfenden Ausdruck enthalten sein. Alles was eingeklammert wird, wird in SubPatterns geschrieben. Diese können dann mit \1,\2...,\n abgerufen werden.
Alles was in einer eckigen Klammer "[]" steht wird als Set bezeichnet. Dort muß lediglich ein Zeichen in dem zu prüfenden Ausdruck enthalten sein.

<b>Achtung</b>: schlechte reguläre Ausdrücke können zu einer dauerhaft hohen CPU-Auslastung führen und diese eventuell beschädigen.

<b><u>Passende Zeichen</u></b>

<h3><u>Globale Einstellungen</u></h3>
Diese Einstellungen werden nur am Anfang des Suchmusters wahrgenommen und wirken sich global aus.

<b>Zeilenumbruch Konventionen</b>
Zeilenumbruchzeichenfolgen werden wahrgenommen wo die <b>^</b> und <b>$</b> Anker gefunden werden aber nicht die <b>\N</b> und <b>.</b> Anker.
Standardmäßig ist die Zeichenfolge für einen Zeilenumbruch das Makro @CRLF nicht umbrechbar. Ebenso wenig @CR und @LF alleine.
Diese Einstellung kann verändert werden indem man einer der folgenden Zeichenfolgen an den Anfang des Suchmusters stellt.
@@ParamTable@@
<b>(*CR)</b>
	Wagenrücklauf (@CR).
<b>(*LF)</b>
	Zeilenvorschub (@LF).
<b>(*CRLF)</b>
	Wagenrücklauf gefolgt von einem Zeilenvorschub (@CRLF).
<b>(*ANYCRLF)</b>
	Irgendeins der @CRLF, @CR oder @LF Makros. Das ist die Standardmäßige Zeilenumbruchkonvention.
<b>(*ANY)</b>
	Jegliche Unicode-Zeilenumbruchsfolge: CRLF, LF, VT, FF, CR oder \x85.
@@End@@

<b>Was \R findet</b>
@@ParamTable@@
<b>(*BSR_ANYCRLF)</b>
	Standardmäßig findet <b>\R</b> ein CRLF, CR oder LF einzeln.
<b>(*BSR_UNICODE)</b>
	Bewirkt, dass <b>\R</b> eins der Unicode-Zeilenumbsuchsfolgen findet: CRLF; LF, VT, FF, CR oder \x85.
@@End@@

<h3><u>Optionen</u></h3>
PCRE-Suchmuster können Optionen enthalten welche sich in <b>(? )</b> Gruppen befinden. Optionen können gruppiert werden, bspw. "(?imx)". Optionen welche einem Bindestrich folgen sind negiert: "(?im-sx)".
Optionen außerhalb einer Gruppe wirken sich auf den Rest des Patterns aus der danach noch folgt. Optionen innerhalb einer Gruppe wirken sich nur auf die Gruppe aus.
Des Weiteren verlieren Optionen ihr besondere Bedeutung innerhalb einer Zeichenklasse, in welcher sie als zu suchendes Zeichen behandelt werden.

@@ParamTable@@
<b>(?i)</b>
	Ohne Groß-/Kleinschreibung: Bei der Auswertung des regulären Ausdrucks wird nach dem Flag nicht zwischen Groß-/Kleinschreibung unterschieden. Dies wird nicht als Gruppe behandelt.
		Wenn UCP aktiviert ist, so wirkt sich die Groß-/Kleinschreibung auf die gesamte Unicode Gruppe 0 aus. Standardmäßig nur auf die ASCII Zeichen A-Z und a-z.
<b>(?m)</b>
	Multiline: ^ und $ finden Zeilenschaltungen innerhalb der Datenmenge. Standardmäßig ist diese Option deaktiviert.
<b>(?s)</b>
	Singleline oder <i>DotAll</i>: <b>.</b> findet alle Zeichen, auch Zeilenumbrüche. Standardmäßig findet "." keine Zeilenumbrüche.
<b>(?U)</b>
	Nicht-Gierig: Kehrt die Standardeinstellung für Gierigkeit der Quantifzierer um und setzt sie auf faul (nicht gierig).
		Standardmäßig ist die Suche gierig, siehe unten für weitere Erläuterung.
<b>(?x)</b>
	Extended: Ignoriert Whitespace-Zeichen außerhalb von Charakterklassen und <b>#</b> beginnt ein Kommentar bis zur nächsten soliden Zeilenumbruch.
		Nichts sagend verbessern die Whitespaces zwischen den Komponenten die Leserlichkeit.
		Standardmäßig matchen Whitespaces sich selbst und <b>#</b> ist ein Zeichen.
@@End@@

<h3><u>Zeichen, Metazeichen und Escaping (oder Zitierung)</u></h3>
<b>Zeichen</b>

Reguläre Ausdrücke bestehen aus Unicodetextzeichen welche sich selbst matchen und zudem aus Zeichenklassen die bestimmte Folgen angeben sowie Optionen.
Bestimmte Folgen und Optionen nutzen einige sogenannte <u>Metazeichen</u> welche eine besondere Bedeutung an sich haben oder spezielle Elemente in einem Muster angeben (siehe dafür die folgende Tabelle).
In Zeichenfolgen, welche nur den Text finden und keine besonderen Muster, stehen alphanumerische Zeichen immer für sich selbst.
Das bedeutet, dass das Suchmuster: "Standardzeichenfolge mit 中国文字" findet exakt den String "Standardzeichenfolge mit 中国文字". ("中国文字" bedeutet "chinesischer Text".)
Dieses Standardverhalten von Strings oder wie sie als Text und nicht als Muster wahrgenommen werden sollen nennt man auch ein Literal.

<b>Repräsentation einiger Zeichen als Literal</b>
Diese nachfolgenden Sequenzen werden verwendet um einige Zeichen als Literal zu interpretieren.

@@ParamTable@@
<b>\a</b>
	Alarmzeichen, gleich dem Kontrollzeichen BEL (Chr(7)).
<b>\c</b><i>X</i>
	Findet ein Kontrollzeichen, basierend auf dem nächsten Zeichen. Zum Beispiel, <b>\cM</b> entspricht Strg-M.
	Genau wie \x0D oder \r (Chr(13)).
<b>\e</b>
	Findet ein Escape-Zeichen (chr(27)). <i>Nicht mit dem Escapen eines Zeichens verwechseln!</i>
<b>\n</b>
	Findet einen Zeilenvorschub(@LF, chr(10)).
<b>\r</b>
	Findet ein Wagenrücklaufzeichen (@CR, chr(13)).
<b>\t</b>
	Findet einen Tabulator (chr(9)).
<b>\</b><i>ddd</i>
	Findet Zeichen mit dem Oktalcode ddd, oder einer Rückreferenz sofern gefunden.
	Findet die vorgegangene Gruppennnummer exakt. Beispielsweise <b>([:alpha:])\1</b> würde ein Doppelzeichen finden.
<b>\x</b><i>hh</i>
	Findet ein Unicode-Zeichen mit dem Hexwert <i>hh</i>: Beispielsweise ist"\x7E" eine Tilde, "~".
<b>\x{</b><i>hhhh</i><b>}</b>
	Findet ein Unicode-Zeichen mit dem Hexwert <i>hhhh</i>: Beispielsweise ist "\x{20AC}" das Eurozeichen, "€" (ChrW(0x20AC)).
<b>\</b><i>x</i>
	wobei <i>x</i> nicht alphanumericsh ist und somit das Literal "x" ist.
	Wird verwendet um Metazeichen als Literal zu interpretieren: "\.\[" wird als Punkt gefolgt von einer eckigen Klammer interpretiert also ".[".
<b>\Q</b> ... <b>\E</b>
	Wörtliche Sequence (Verbatim): Metazeichen verlieren ihre spezielle Bedeutung zwischen <b>\Q</b> und <b>\E</b>.
	"\Q(.)\E" findet "(.)". Es ist äquivalent zum Escapen des Charakters (vorhin erwähnt) und ist einfacher zu lesen als "\(\.\)".
@@End@@

@@Metazeichen@@
PCRE kennt folgende Metazeichen <b>\ . ^ $ | [ ( { * + ? #</b> und jedes einzelne davon kann eine oder mehrere Bedeutungen haben welche vom aktuellen Kontext abhängt.
Um ein Metazeichen als Literal einzufügen, so muss man das Zeichen Escapen, dies geschieht mit einem einfachen Backslash: "\$" wird zu "$".
Metazeichen werden in später in einer Untersektion noch weiter besprochen so wie ihre Bedeutungen.

<h3><u>Zeichentypen</u></h3>
@@ParamTable@@
<b>.</b>
	Findet jedes einzelne Zeichen außer, standardmäßig, eines Zeilenumbruchs. Findet auch Zeilenumbrüche wenn die Option <b>(?s)</b> aktiviert wurde.
<b>\d</b>
	Findet eine Dezimalziffer (0 bis 9). Auch jegliche Unicodedezimalziffer in jeglicher Sprache sofern UCP aktiviert wurde).
<b>\D</b>
	Findet alles außer Ziffern.
<b>\h</b>
	Findet alle waagerechten Whitespace-Zeichen (siehe Tabelle weiter unten).
<b>\H</b>
	Findet alle Zeichen außer waagerechte Whitespace-Zeichen.
<b>\N</b>
	Findet alle Zeichen außer Zeilenumrüche ungeachtet dessen ob die Option <b>(?s)</b> aktiviert wurde.
<b>\p{</b><i>ppp</i><b>}</b>
	Nur wenn UCP aktiviert wurde: Findet alle Unicode-Zeichen mit der Eigenschaft <i>ppp</i>.
	Beispielsweise findet "\b\p{Cyrillic}+" alle kyrillischen Wörter. "\p{Sc}" jegliches Währungssymbol.
	Siehe die oben genannte Dokumentation für weitere Erläuterungen und Details.
<b>\P{</b><i>ppp</i><b>}</b>
	Nur wenn UCP aktiviert wurde: Findet alle Unicode-Zeichen die nicht die gegebene Eigenschafft <i>ppp</i> haben.
<b>\R</b>
	Findet alle Unicode-Zeilenumbrüche standardmäßig oder die der aktiven (*BSR_...) Einstellung.
	Standardmäßig findet <b>\R</b> "(?>\r\n|\n|\r)" wobei "(?<...)" eine atomare Gruppe ist welche die Folge "\r\n" (@CRLF) nicht umbrechbar macht.
<b>\s</b>
	Findet alle Whitespace-Zeichen: Chr(9) bis Chr(13), welche Tabulator, Zeilenschaltung, senkrechter Tab, Seitenvorschub, Wagenrücklauf und das Leerzeichen sind ( Chr(32) ).
<b>\S</b>
	Findet alles außer Whitespace-Zeichen.
<b>\v</b>
	Findet alle vertikalen Whitespace-Zeichen (siehe Tabelle weiter unten).
<b>\V</b>
	Findet alle Zeichen außer vertikale Whitespace-Zeichen.
<b>\w</b>
	Findet alle Wörterzeichen: a-z, A-Z ,0-9 oder Unterstrich (_).
<b>\W</b>
	Findet alle Nicht-Wörterzeichen.
<b>\X</b>
	Nur wenn UCP aktiviert wurde: findet alle erweiterten Unicode Grapheme Cluster welches eine nicht umbrechbare Sequenz an Codepunkten ist welche ein einziges Zeichen für einen Nutzer darstellen.
		Als Konsequenz findet <b>\X</b> mehr als ein Zeichen im Eingabestring gegenteilig zu all den anderen Sequenzen in dieser Tabelle.
@@End@@

<h3><u>Mengen von Whitespace-Zeichen (Leerzeichen)</u></h3>
<b>Horizontale Whitespace-Zeichen welche von \h gefunden werden</b>

<b>\h</b> ist standardmäßig äquivalent zu "[\x09 \xA0]" (oder "[\x09 \xA0\x{1680}\x{180E}\x{2000}-\x{200A}\x{202F}\x{205F}\x{3000}]" when UCP aktiviert wurde.)
Diese Menge besteht aus: Horizontaler Tab (HT), Leerzeichen (Space), nicht-brechendes Leerzeichen
(unter anderem: Ogham Leerzeichen Markierung, Monoglischer Vokalseparator, En quad, Em quad, Em space, Three-per-em space, Four-per-em space, Six-per-em space, Figure space,
Punctuation space, Thin space, Hair space, Narrow no-break space, Medium mathematical space, Ideographic space wenn UCP aktiviert wurde.)

<b>Vertikale Whitespace-Zeichen welche von \v gefunden werden</b>
<b>\v</b> ist standardmäßig äquivalent zu "[\x0A-\x0D]" (oder "[\x0A-\x0D\x{0085}\x{2028}\x{2029}]" wenn UCP aktiviert wurde.)
Diese Menge besteht aus: Zeilenvorschub (LF), Vertikaler Tab (VT), Form feed (FF), Wagenrücklauf (CR) (unter anderem: Nächste Zeile (Next Line (NEL)), Zeilenseparator (Line Separator), Paragraph Separator wenn UCP aktiviert wurde.)

<b>Whitespace-Zeichen welche von \s gefunden werden</b>
<b>\s</b> ist äquivalent zu "[\h\x0A\x0C\x0D]".
Diese Menge besteht aus: Allen Zeichen in <b>\h</b> und Zeilenvorschub (LF), Form feed (FF), Wagenrücklauf (CR).

<b>Whitespace-Zeichen welche von [[:space:]] gefunden werden</b>
<b>[[:space:]]</b> ist äquivalent zu "[\h\x0A-\x0D]".
Diese Menge besteht aus: Allen Zeichen in <b>\s</b> und dem vertikalen Tab (VT).


<h3><u>Zeichenklassen und POSIX Klassen</u></h3>
<b>Zeichenklassen</b>

Eine Zeichenklasse definiert eine Menge von erlaubten (respektive verbotenen) Zeichen, welches dem nächsten Zeichen im Eingabestring überstimmen (respektive nicht übereinstimmen) muss.
Innerhalb einer Zeichenklasse verlieren die meisten der Metazeichen ihre spezielle Bedeutung (wie z.B. $ . oder *) oder bedeuten etwas anderes (wie z.B. ^).

@@ParamTable@@
<b>[</b> ... <b>]</b>                                                                                                                                          
	Findet jedes Zeichen in der Menge. <b>[aeiou]</b> findet alle kleingeschriebenen Vokale.
	Eine zusammenhängende Menge kann definiert werden, indem ein Bindestrich zwischen dem ersten und letzten Zeichen gesetzt wird. <b>[a-z]</b> findet alle kleingeschriebenen Zeichen.
	Um einen Bindestrich in einer Menge einzubeziehen (<b>-</b>), ist der Bindestrich als erstes, letztes Zeichen des Sets zu verwenden oder er kann auch escaped werden (\-).
	Man sollte beachten, dass das Muster "[A-z]" nicht dasselbe wie "[A-Za-z]": das Vorherige ist äquivalent zu "[A-Z\[\\\]^_`a-z]".
	Um eine schließende Klammer in einer Menge zu verwenden, ist es als erstes Zeichen in der Menge zu verwenden oder man muss ihn escapen: "[][]" und "[\[\]]" werden beide entweder "[" oder "]" finden.
	Es ist zu beachten, dass in einer Charakterklasse nur <b>\d</b>, <b>\D</b>, <b>\h</b>, <b>\H</b>, <b>\p{}</b>, <b>\P{}</b>, <b>\s</b>, <b>\Q</b>...<b>\E</b>, <b>\S</b>,
	<b>\v</b>, <b>\V</b>, <b>\w</b>, <b>\W</b>, und <b>\x</b> Sequenzen ihre besondere Bedeutung behalten, wobei <b>\b</b> gleich dem Backspacezeichen ist (Chr(8)).
<b>[^</b> ... <b>]</b>
	Findet alle Zeichen welche <b>nicht</b> in der Menge enthalten sind: "[^0-9]" findet alle Nicht-Ziffern.
	Um ein Caret (^) in die Menge einzubinden, muss es nach dem Anfang der Menge stehen oder seine Bedeutung muss mittels Escaping aufgehoben werden (\^).
@@End@@

<b>POSIX Klassen</b>
Diese benannten Mengen werden innerhalb einer Charakterklasse verwendet: "[z[:digit:]w-y]" ist äquivalent zu "[w-z0-9]".
Um eine POSIX Klasse zu negieren muss ein Caret (^) nach dem ersten Doppelpunkt stehen: "[[:^digit:]]".
Wenn UCP aktiviert wurde, werden einige POSIX Klassen zu einigen Unicode Charakteruntermengen erweitert werden.
Anderenfalls sind sie standardmäßig zu 7-bit ASCII limitiert.

@@ParamTable@@
<b>[:alnum:]</b>
	ASCII-Zeichen und Ziffern (die selben wie [^\W_] oder [A-Za-z0-9]).
	Wenn UCP aktiviert wurde: Unicode-Zeichen (die selben wie [^\W_] oder \p{Xan}).
<b>[:alpha:]</b>
	ASCII-Zeichen (die selben wie [^\W_] oder [A-Za-z]).
	Wenn UCP aktiviert wurde: Unicode-Zeichen (die selben wie [^\W_] oder \p{L}).
<b>[:ascii:]</b>
	ASCII-Zeichen (die selben wie ([\x00-\x7F])).
<b>[:blank:]</b>
	Leerzeichen oder Tab (@TAB) (die selben wie \h oder [\x09\x20]).
	Wenn UCP aktiviert wurde: horizontale Unicode-Whitespaces (die selben wie \h).
<b>[:cntrl:]</b>
	ASCII-Kontroll-Zeichen (die selben wie (Chr(0) ... Chr(31) und Chr(127))).
<b>[:digit:]</b>
	ASCII-Dezimalziffern (die selben wie \d oder [0-9]).
	Wenn UCP aktiviert wurde: Unicode-Dezimalziffern (die selben wie \d oder \p{Nd}).
<b>[:graph:]</b>
	ASCII-Druck-Zeichen, ohne dem Leerzeichen (die selben wie Chr(33) ... Chr(126)).
<b>[:lower:]</b>
	ASCII-Kleinbuchstaben-Zeichen (die selben wie [a-z])
	Wenn UCP aktiviert wurde: Unicode-Kleinbuchstaben-Zeichen (die selben wie \p{L1}).
<b>[:print:]</b>
	ASCII-Druck-Zeichen, mit dem Leerzeichen (die selben wie (Chr(32) ... Chr(126))
<b>[:punct:]</b>
	ASCII-Punkt-Zeichen, [:print:] ohne [:alnum:] und dem Leerzeichen (33-47, 58-64, 91-96, 123-126)
<b>[:space:]</b>
	ASCII-Whitespace-Zeichen (die selben wie [\h\x0A-\x0D]). <b>[:space:]</b> ist nicht genau das gleiche wie <b>\s</b>: es beinhaltet VT, Chr(11).
<b>[:upper:]</b>
	ASCII-Großbuchstaben-Zeichen (die selben wie [A-Z]).
	Wenn UCP aktiviert wurde: Unicode-Großbuchstaben-Zeichen (die selben wie \p{Lu}).
<b>[:word:]</b>
	ASCII-"Wort"-Zeichen (die selben wie \w oder [[:alnum:]_]).
	Wenn UCP aktiviert wurde: Unicode-"Wort"-Zeichen (die selben wie \w oder [[:alnum:]_] oder \p{XwD}).
<b>[:xdigit:]</b>
	Hexadezimale Ziffern (die selben wie [0-9A-Fa-f]).
@@End@@

<h3><u>Gruppen</u></h3>
Gruppen werden verwendet um Untermuster zu trennen und sind essenzielle Bestandteile mächtiger regulärer Ausdrücke.
Gruppen können entweder fangend (abspeichernd, capturing) oder ignorierend sein und können ungeachtet ihrer Natur (bis auf Kommentargruppen) geschachtelt werden.
Ein regulärer Ausdruck darf bis zu 65535 (2^16 - 1) fangende Gruppen enthalten.
Optionszeichen (bereits erwähnt) können einfach zwischen "?" und dem ":" einer nicht-fangenden Gruppe eingefügt werden:
"(?-i:[aeiou]{5})" findet fünf kleingeschriebene Vokale. In diesem Fall sind die Optionen nur lokal in der Gruppe angewendet und nicht global.

@@ParamTable@@
<b>(</b> ... <b>)</b>
	Gruppe. Die Elemente in der Gruppe werden in Reihenfolge bearbeitet und können zusammen wiederholt werden.
		Zum Beispiel entspricht"(ab)+c" "abc" oder "ababc", aber nicht "abac". Eine Gruppe speichert auch den Text ab, der mit der Menge übereinstimmt,
		um ihn bei einem Rückverweis und in dem Rückgabearray der Funktion zu benutzen, abhängig von dem Flag-Parameter.
		Sie werden nummeriert beginnend von der 1 in der Reihenfolge wie ihre Klammeröffnungen sind.
		Gruppen können auch als Unterroutinen in einem anderen Bereich des Musters behandelt werden, sogar rekursiv.
<b>(?&lt;</b><i>name</i><b>&gt;</b> ... <b>)</b>
	Benannte Gruppe. Kann später mittels Name sowie als Nummer referenziert werden.
		Es sollte vermieden werden den Namen "DEFINE" zu verwenden (Siehe "Bedinge Muster").
<b>(?:</b> ... <b>)</b>
	Nicht-fangende Gruppe. Speichert keine der übereinstimmenden Zeichen im Array und kann nicht als Rückreferenz verwendet werden.
<b>(?|</b> ... <b>)</b>
	Nicht-fangende Gruppe mit Reset. Setzt die Gruppein jeder Top-Level-Alternative (höchste Klammerung) zurück:"
		"(?|(Mon)|(Tue)s|(Wed)nes|(Thu)rs|(Fri)|(Sat)ur|(Sun))day" findet einen Wochentag und ihre Abkürzung in der Gruppennummer 1.
<b>(?></b> ... <b>)</b>
	Atomare nicht-fangende Gruppe: Speert und backtrackt von dem was gefunden wurde. (Siehe Quantifizierer und Gierigkeit weiter unten.)
		Atomare Gruppen, wie besitzergreifende Quantifizierer, sind immer gierig.
<b>(?#</b> ... <b>)</b>
	Kommentargruppe: Werden immer ignoriert (darf keine geschlossene Klammern ")" enthalten, aus diesem Grunde sind sie auch nicht schachtelbar).
@@End@@

<h3><u>Quantifizierer und Gierigkeit</u></h3>
Quantifizierer (oder Wiederholungsspezifizierer) geben an wie viele vorangehende Zeichen, Klassen, Referencen oder Gruppen gefunden werden sollen.
Optionale Gierigkeit gibt an wie aggressiv sich die Wiederholung verhalten soll. Beispielsweise findet "\d{3,5}" mindestens drei aber nicht mehr als fünf Dezimalziffern.
Standardmäßig sind die Muster "<u>gierig</u>", was bedeutet, dass Quantifizierer wie <b>* + ? {</b>...<b>}</b> den längsten String finden welcher noch den Rest des Musters erfüllt.
Gierigkeit kann für das gesamte Muster invertiert werden indem man die Option (?U) am Anfang ds Musters angibt oder lokal indem man ein Fragezeichen "?" nach einem Quantifizierer setzt.
nicht-gieriger (<u>faul</u>) Wiederholungen werden den kleinsten möglichen String finden welcher noch den Rest des Musters erfüllt.
Bei einem Eingabestring von "aaab" wird das Muster "(a*)([ab]+)" "aaa" finden und dann "b" aber "(?U)(a*)([ab]+)" findet "" dann "a":
Ein leerer String ist genug um das faule "(a*)" zu erfüllen und das gefangene "a" wird vom "([ab]+)" Untermuster gefunden.

Besitzergreifende Quantifizierer sind atomar und gierig. Sie sind eine Abkürzung für simple atomare Gruppen.
"\d++" ist eine Abkürzung für "(?>\d+)" und dessen Verhalten ist "finde eine komplette Sequenz von einer oder mehreren Ziffern aber gib niemals eins davon zurück".
In Konsequenz kann "\d++<b>(\d</b>)" niemals die letzte Ziffer (in fetter Schriftart) finden, da das letzte Zeichen bereits gefunden und von "\d++" gesperrt wurde.

Dies in Betrachtung mit der einfachen Gierigkeit, wo "\d+(\d)" erst die komplette Sequenz mit Ziffern mit "\d+" findet aber dann das letzte backtrackt um "<b>(\d)</b>" zu erlauben, dass es es fangen kann.
Es gibt mehr als zwei Gründe um atomare Gruppen oder besitzergreifende Quantifizierer zu nutzen:
Entweder um eine Folge von Zeichen zu finden welche auch individuell auftauchen können (z.B. "\r\n" in der Definition von <b>\R</b>),
oder um das schnelle Scheitern der Engine herbeizuführen wo man ungebundene Wiederholungen verwendet damit die Engine nicht sehr große Gruppen sucht und dann scheitert.

@@ParamTable@@
<b>?</b>
	0 oder 1, gierig.
<b>?+</b>
	0 oder 1, besitzergreifend.
<b>??</b>
	0 oder 1, faul.
<b>*</b>
	0 oder mehr, gierig.
<b>*+</b>
	0 oder mehr, besitzergreifend.
<b>*?</b>
	0 oder mehr, faul.
<b>+</b>
	1 oder mehr, gierig.
<b>++</b>
	1 oder mehr, besitzergreifend.
<b>+?</b>
	1 oder mehr, faul.
<b>{</b><i>x</i><b>}</b>
	genau <i>x</i>.
<b>{</b><i>x</i><b>,</b><i>y</i><b>}</b>
	mindestens <i>x</i> und nicht mehr als <i>y</i>, gierig.
<b>{</b><i>x</i><b>,</b><i>y</i><b>}+</b>
	mindestens <i>x</i> und nicht mehr als <i>y</i>, besitzergreifend.
<b>{</b><i>x</i><b>,</b><i>y</i><b>}?</b>
	mindestens <i>x</i> und nicht mehr als <i>y</i>, faul.
<b>{</b><i>x</i><b>,}</b>
	<i>x</i> oder mehr, gierig.
<b>{</b><i>x</i><b>,}+</b>
	<i>x</i> oder mehr, besitzergreifend.
<b>{</b><i>x</i><b>,}?</b>
	<i>x</i> oder mehr, faul.
@@End@@

<h3><u>Verschiebung (Alternation)</u></h3>
@@ParamTable@@
<i>X</i><b>|</b><i>Y</i>
	Findet entweder das Untermuster <i>X</i> oder <i>Y</i>: "ab|dc|ground" findet "ac" oder "dc" oder "ground".
@@End@@

<h3><u>Rückreferenzen und Referenzen zu Unterroutinen</u></h3>
<b>Rückreferenzen</b> erlauben es einem den Inhalt einer vorgegangenen gefangenen Gruppe zu nutzen.

@@ParamTable@@
<b>\</b><i>n</i>
	Referenziert eine vorgegangene Gruppe durch ihre absolute Nummer. 
		Warnung: Wenn die Gruppennummer <i>n</i> nicht existiert, wird es als Zeichen mit einem Wert <i>n</i> behandelt. Sofern <i>n</i> keine gültige Oktalzahl ist erfolgt ein Error.
		Aufgrund dieser Mehrdeutigkeit ist diese Form nicht zu empfehlen. Die nachfolgenden Formen sind eher zu bevorzugen.
<b>\g</b><i>n</i>
	Referenziert eine vorgegangene Gruppe durch ihre absolute Nummer.
<b>\g{</b><i>n</i><b>}</b>
	Referenziert eine vorgegangene Gruppe durch ihre absolute Nummer. Ähnlich wie das obere aber hier wird deutlich wo <i>n</i> beginnt und aufhört:
		Hilfreich wenn die folgenden Zeichen Ziffern sind.
<b>\g-</b><i>n</i>
	Referenziert eine vorgegangene Gruppe durch ihre relative Nummer.
<b>\k&lt;</b><i>name</i><b>&gt;</b>
	Referenziert eine vorgegangene durch ihren Namen.
@@End@@

<b>Referenzen zu Unterroutinen</b>
Fangende Gruppen sind Untermuster welche aufgerufen werden können (auch rekursiv) genau wie eine Subroutine in einer Programmiersprache. In AutoIt wäre das beispielsweise eine Funktion.
Das Untermuster wird einfach am aktuellen Punkt neu ausgeführt. Siehe Referenzdokumentation für Details und Beispiele.

@@ParamTable@@
<b>(?R)</b> or <b>(?0)</b>
	Führt das gesamte Suchmuster rekursiv neu aus.
<b>(?</b><i>n</i><b>)</b>
	Ruft ein Untermuster durch ihre absolute Nummer auf.
<b>(?+</b><i>n</i><b>)</b>
	Ruft ein Untermuster durch ihre relative Nummer auf.
<b>(?-</b><i>n</i><b>)</b>
	Ruft ein Untermuster durch ihre relative Nummer auf.
<b>(?&</b><i>name</i><b>)</b>
	Ruft ein Untermuster durch ihren Namen auf.
@@End@@

<h3><u>Anker (Anchors) und Behauptungen (Assertions)</u></h3>
Anker und Behauptungen sind tests die an der aktuellen Abfrageposition nichts verändern und dadurch werder Zeichen verschlingen oder welche fangen.

Ein <b>Anker</b> testet die Position an der aktuellen Abfrageposition.

@@ParamTable@@
<b>^</b>
	Das Caret-Zeichen findet außerhalb einer Charakterklasse den Start des Eingabestrings und den Beginn einer neuen Zeile nach einem nicht-finalen Zeilenumbruch (nicht-final bedeutet, das danach noch Text folgt) sofern die option <b>(?m)</b> aktiv ist.
	Standardmäßig ist die Zeilenumbruchsfolge der Wagenrücklauf @CRLF.
	Innerhalb einer Charakterklasse komplementiert das Caret <b>^</b> die Klasse indem es alle Buchstaben die danach folgen nicht findet.
<b>$</b>
	Außerhalb einer Charakterklasse findet das Dollar-Zeichen das Ende des Eingabestrings oder das Ende einer Zeile markiert durch einen Zeilenumbruch sofern <b>(?m)</b> aktiv ist.
	Innerhalb einer Charakterklasse wird das <b>$</b> als Literal behandelt und hat keine spezielle Bedeutung.
<b>\A</b>
	Findet nur am absoluten Anfang des Eingabestrings unabhängig von der multiline-Option <b>(?m)</b>. Findet nie wenn der Offset nicht 1 ist.
<b>\G</b>
	Findet nur wenn die aktuelle Position die Position des ersten Fundes im Eingabestring ist.
<b>\z</b>
	Findet nur am Ende des Eingabestrings unabhängig von der multiline-Option <b>(?m)</b>.
<b>\Z</b>
	Findet nur am Ende des Eingabestrings oder vor einem Zeilenumbruch am Ende unabhängig von der multiline-Option <b>(?m</b>.
@@End@@

Eine <b>Behauptungen</b> testet die Zeichen vorangehend (look-behind), am (Wortgrenze, word boundary) oder folgend (look-ahead) der aktuellen Abfrageposition.

@@ParamTable@@
<b>\b</b>
	Findet bei Wortgrenze. Das heißt zwischen Zeichen und nicht beide <b>\w</b> oder <b>\W</b>. Siehe <b>\w</b> für die Bedeutung des Kennzeichners "Wort".
	Innerhalb einer Charakterklasse bedeutet <b>\b</b> ein Backspace (Chr(8)).
<b>\B</b>
	Findet wenn es nicht an der Wortgrenze ist.
<b>(?=</b><i>X</i><b>)</b>
	Positiv Folgend: Findet, wenn das Untermuster <i>X</i> an der aktuellen Abfrageposition übereinstimmt.
<b>(?!</b><i>X</i>)</b>
	Negativ Folgend: Findet, wenn das Untermuster <i>X</i> an der aktuellen Abfrageposition nicht übereinstimmt.
<b>(?&lt;=</b><i>X</i><b>)</b>
	Positiv Vorangehend: Findet, wenn das Untermuster <i>X</i> an den vorangehenden Zeichen übereinstimmt.
		Das Untermuster <i>X</i> muss eine feste Länge besitzen und darf nicht undefinierte Quantifizierer wie <b>* + oder ? </b> enthalten.
<b>(?&lt;!</b><i>X</i><b>)</b>
	Negativ Vorangehend: Findet, wenn das Untermuster <i>X</i> an den vorangehenden Zeichen nicht übereinstimmt.
		Das Untermuster <i>X</i> muss eine feste Länge besitzen und darf nicht undefinierte Quantifizierer wie <b>* + oder ? </b> enthalten.
@@End@@

<h3><u>Zurücksetzung des Fundes (Reset)</u></h3>
Es kann vorkommen, dass es notwendig ist das bisher gefundene zu verwerfen um relevantere Daten später im Eingabestring zu finden.

@@ParamTable@@
<b>\K</b>
	Setzt den Beginn eines Fundes an die aktuelle Abfrageposition im Eingabestring. Man sollte dabei beachten, dass bereits gefangene Gruppen nun alleine stehen und immer noch im Rückgabearray auftauchen und
		dadurch ist es möglich sie später auch zu referenzieren. Die Aktion durch <b>\K</b> ist ähnlich aber nicht identisch zum vorangehenden Vorgehensweise (look-behind) und unterscheidet sich darin,
		dass <b>\K</b> mit verschiedenen Längen arbeiten kann.
@@End@@

<h3><u>Bedingte Muster</u></h3>
Diese Konstrukte sind ähnlich zu <b><i>If...EndIf</i></b> und <b><i>If...Else...EndIf</i></b> Verzweigungen.

@@ParamTable@@
<b>(?</b><i>(Bedingung)yes-pattern</i><b>)</b>
	Erlaubt die bedingte Ausführung eines Musters.
<b>(?</b><i>(Bedingung)erfüllendes-Muster</i><b>|</b><i>nicht-erfüllendes-Muster</i><b>)</b>
	Wählt zwischen zwei bestimmten Mustern je nach dem Ergebnis der <i>(Bedingung)</i>.
@@End@@
    wobei <i>(Bedingung)</i> einer der folgenden Formen annehmen kann:
@@ParamTable@@
<b>(</b><i>n</i><b>)</b>
	Testet, ob die gefangene Gruppe mit einer absoluten Nummer <i>n</i> gefunden wurde.
<b>(+</b><i>n</i><b>)</b>
	Testet, ob die gefangene Gruppe mit einer relativen Nummer <i>+n</i> gefunden wurde.
<b>(-</b><i>n</i><b>)</b>
	Testet, ob die gefangene Gruppe mit einer relativen Nummer <i>-n</i> gefunden wurde.
<b>(&lt;</b><i>name</i><b>&gt;)</b>
	Testet, ob die gefangene Gruppe mit dem Namen <i>name</i> gefunden wurde.
<b>(R)</b>
	Testet, ob eine Rekursion stattfand.
<b>(R</b><i>n</i><b>)</b>
	Testet, ob die letzte Rekursion für eine gefangene Gruppe mit der absoluten Nummer <i>n</i> war.
<b>(R&amp;</b><i>name</i><b>)</b>
	Testet, ob die letzte Rekursion für eine gefangene Gruppe mit dem Namen <i>name</i> war.
<b>(DEFINE)</b>
	Wird <i>ohne</i> Pattern benutzt und erlaubt die Zuweisung der Unterroutine von woanders.
	"(?x) (?(DEFINE) (?&lt;byte&gt; 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )" definiert die Unterroutine "byte" welche eine der Komponenten einer IPv4-Adresse findet.
	Die eigentliche Adresse kann mit "\b (?&amp;byte) (\.(?&amp;byte)){3} \b" gefunden werden.
<b>(</b><i>assertion</i><b>)</b>
	Hier ist <i>assertion</i> ist entweder eine positive oder negative, vorangehende (look-behind) oder folgende (look-ahead) Assertion (Behauptung).
@@End@@

<h3><u>Diverse fortgeschrittenere Features</u></h3>
Diese Optionen, die Escapes und die Konstrukte werden hier nur genannt, für eine Erläuterung warum, wie und wann man sie nutzen sollte siehe die Referenzdokumentation.

<b>Ungewöhnliche Einstellungen und Optionen</b>

@@ParamTable@@
<b>(?J)</b>
	Erlaubt Dubletten in Gruppen- und Unterroutinennamen (hier nicht weiter erläutert).
<b>(?X)</b>
	Verursacht Fehler durch einige out-of-context Sequenzen.
<b>(*J)</b>
	Aktiviert die Javascript-Kompatibilität (hier nicht weiter erläutert).
<b>(*LIMIT_MATCH=</b><i>n</i><b>)</b>
	Limitiert die Anzahl der Funde auf <i>n</i>.
<b>(*LIMIT_RECURSION=</b><i>n</i><b>)</b>
	Limitiert die maximale Rekursionstiefe auf <i>n</i>.
<b>(*NO_START_OPT)</b>
	Deaktiviert einige Optimierungen (hier nicht weiter erläutert).
@@End@@

<b>Backtracking Steuerung</b>
@@ParamTable@@
<b>(*ACCEPT)</b>
	Erzwingt einen sofortigen Sucherfolg in der aktuellen Unterroutine oder im Top-Level-Muster (dem höchsten).
<b>(*FAIL)</b> or <b>(*F)</b>
	Erzwingt einen sofortigen Suchmisserfolg.
<b>(*MARK:</b><i>name</i><b>)</b> or <b>(*:</b><i>name</i><b>)</b>
	<i>(Siehe Referenzdokumentation.)</i>
<b>(*COMMIT)</b>
	<i>(Siehe Referenzdokumentation.)</i>
<b>(*PRUNE)</b>
	<i>(Siehe Referenzdokumentation.)</i>
<b>(*PRUNE:</b><i>name</i><b>)</b>
	<i>(Siehe Referenzdokumentation.)</i>
<b>(*SKIP)</b>
	<i>(Siehe Referenzdokumentation.)</i>
<b>(*SKIP:</b><i>name</i><b>)</b>
	<i>(Siehe Referenzdokumentation.)</i>
<b>(*THEN)</b>
	<i>(Siehe Referenzdokumentation.)</i>
<b>(*THEN:</b><i>name</i><b>)</b>
	<i>(Siehe Referenzdokumentation.)</i>
@@End@@

<h3><u>Allgemeinte Kommentare über reguläre Ausdrücke in AutoIt</u></h3>
	1. Wenn UCP aktiviert ist wirkt sich die Groß-/Kleinschreibung auf das gesamte Unicode Gruppe 0 aus, standardmäßig nur auf die ASCII-Zeichen A-Z und a-z.
		Es existiert eine kleine Anzahl an viele-zu-einen (many-to-one) Verknüpfungen in Unicode wie z.B. das kleine griechische Sigma, diese werden durch PCRE mit UCP aktiviert unterstützt.
		
	2. Es existieren verschiedene Formen für das Escapen um eine Kompatibilität mit Perl, Ruby, Python, Javascript, .NET und anderen Engines herzustellen.
		Man sollte auf keinen Fall keine Konstrukte verwenden welche hier nicht aufgezählt wurden, denn einige funktionieren schlicht nicht, einige liefern falsche Resultate und einige bergen große Fehler oder stürzen ab.
		
	3. Die Standard-Zeilenumbruch-Konventionen ist die nicht-umbrechbare Sequenz @CRLF oder ein separates @CR bzw. @LF.
		Auf ähnliche Weise findet \R seine Gruppen durch die selbe Menge.
		Man sollte immer wissen was man als Eingabestring nimmt. Bedeutet der Wagenrücklauf (@CR) bzw. der Zeilenvorschub (@LF) was anderes als ihre eigentliche Bedeutung,
		so sollte man eventuell die Zeilenumbruchskonvention anpassen oder die Bedeutung des \R (siehe "Einstellungen").

Siehe auch das <a href="../tutorials/regexp/regexp.htm">Reguläre Ausdrücke Tutorial</a> in welchem man ein Script zum testen der eigenen regulären Ausdrücke ausführen kann.


###Related###
StringInStr, StringRegExpReplace


###Example###
@@IncludeExample@@
